package cn.com.taiji.oospub.wechat.common.tool;

import org.springframework.util.StringUtils;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Calendar;
import java.util.Date;

public abstract class TimeTools {
	public static final String DEFAULT_FORMAT = "yyyy-MM-dd HH:mm:ss";
	public static final String DAY_FORMAT = "yyyy-MM-dd";
	public static final String MONTH_FORMAT = "yyyy-MM";
	public static final DateFormat DEFAULT_FORMATTER = new SimpleDateFormat(
			DEFAULT_FORMAT);

	public static Calendar startOfDay(Calendar c) {
		if (c == null) {
			return c;
		}
		c.set(Calendar.HOUR_OF_DAY, 0);
		c.set(Calendar.MINUTE, 0);
		c.set(Calendar.SECOND, 0);
		c.set(Calendar.MILLISECOND, 0);
		return c;
	}

	public static Calendar endOfDay(Calendar c) {
		if (c == null) {
			return c;
		}
		c.set(Calendar.HOUR_OF_DAY, 23);
		c.set(Calendar.MINUTE, 59);
		c.set(Calendar.SECOND, 59);
		c.set(Calendar.MILLISECOND, 998);
		return c;
	}
	public static Calendar endOfDay2(Calendar c) {
		if (c == null) {
			return c;
		}
		c.set(Calendar.HOUR_OF_DAY, 23);
		c.set(Calendar.MINUTE, 59);
		c.set(Calendar.SECOND, 59);
		c.set(Calendar.MILLISECOND, 0);
		return c;
	}

	/**
	 * 将给定字符串转换为日期,如果没有设置解析器，则用默认格式（yyyy-MM-dd HH:mm:ss）解析
	 * 
	 * @param s
	 *            给定字符串
	 * @param format
	 *            解析格式
	 * @return 日期对象
	 * @throws ParseException
	 */
	public static Calendar string2Calendar(String s, DateFormat format)
			throws ParseException {
		if (!StringUtils.hasText(s)) {
			return null;
		}
		Calendar c = Calendar.getInstance();
		Date date = (format == null ? DEFAULT_FORMATTER : format).parse(s);
		c.setTimeInMillis(date.getTime());
		return c;
	}

	/**
	 * 将给定字符串转换为日期,如果没有设置解析字符串，则用默认格式（yyyy-MM-dd HH:mm:ss）解析
	 * 
	 * @param s
	 *            给定字符串
	 * @param format
	 *            解析字符串
	 * @return 日期对象
	 * @throws ParseException
	 */
	public static Calendar string2Calendar(String s, String format)
			throws ParseException {
		return string2Calendar(s,
				new SimpleDateFormat(StringUtils.hasText(format) ? format
						: DEFAULT_FORMAT));
	}

	/**
	 * 将给定字符串按照缺省解析格式（yyyy-MM-dd HH:mm:ss）转换为日期
	 * 
	 * @param s
	 * @return
	 * @throws ParseException
	 */
	public static Calendar string2Calendar(String s) throws ParseException {
		return string2Calendar(s, DEFAULT_FORMAT);
	}
	/**
	 * 将给定字符串按照缺省解析格式（yyyy-MM-dd）转换为日期
	 * 
	 * @param s
	 * @return
	 * @throws ParseException
	 */
	public static Calendar string2Day(String s) throws ParseException {
		return string2Calendar(s, DAY_FORMAT);
	}
	/**
	 * 将给定的日期格式化输出，如果没有设置输出格式，则采用模式格式（yyyy-MM-dd HH:mm:ss）输出
	 * 
	 * @param c
	 *            日期
	 * @param format
	 *            解析格式
	 * @return
	 */
	public static String calendar2String(Calendar c, DateFormat format) {
		if (c == null) {
			return null;
		}
		return (format == null ? DEFAULT_FORMATTER : format)
				.format(c.getTime());
	}


	public static String localDateTime2String(LocalDateTime c, String formatStr) {
		DateTimeFormatter format = DateTimeFormatter.ofPattern(formatStr);

		if (c == null) {
			return null;
		}
		return c.format(format);
	}

	public static String localDate2String(LocalDate c, String formatStr) {
		DateTimeFormatter format = DateTimeFormatter.ofPattern(formatStr);

		if (c == null) {
			return null;
		}
		return c.format(format);
	}
	/**
	 * 将给定字符串转换为日期,如果没有设置解析字符串，则用默认格式（yyyy-MM-dd HH:mm:ss）解析
	 *
	 * @param s
	 *            给定字符串
	 * @param formatStr
	 *            解析字符串
	 * @return 日期对象
	 */
	public static LocalDateTime string2LocalDateTime (String s, String formatStr) {
		DateTimeFormatter format = DateTimeFormatter.ofPattern( StringUtils.hasText(formatStr) ? formatStr:DEFAULT_FORMAT);
		return LocalDateTime.parse(s,format);
	}


	/**
	 * 将给定的日期格式化输出，如果没有设置输出格式，则采用模式格式（yyyy-MM-dd HH:mm:ss）输出
	 * 
	 * @param c
	 *            日期
	 * @param format
	 *            解析格式
	 * @return
	 */
	public static String calendar2String(Calendar c, String format) {
		return calendar2String(c,
				(StringUtils.hasText(format) ? new SimpleDateFormat(format)
						: DEFAULT_FORMATTER));
	}

	/**
	 * 将给定的日期格式化输出，采用缺省格式（yyyy-MM-dd HH:mm:ss）
	 * 
	 * @param c
	 *            日期
	 * @return
	 */
	public static String calendar2String(Calendar c) {
		return calendar2String(c, DEFAULT_FORMATTER);
	}

	/**
	 * 将给定的日期字符串格式化为日期+时分秒 00:00:00
	 * @author: lihong
	 * @param startDate
	 * @return
	 */
	public static String String2Start(String startDate) {
		return startDate + " 00:00:00";
	}
	
	/**
     * 将给定的日期字符串格式化为年月 2012-10
     * @author: lihong
     * @return
     */
    public static String String2YearMonth(String dailyDate) {
        if (!StringUtils.hasText(dailyDate)) {
			return null;
		}
        return dailyDate.substring(0, 7);
    }
	
	/**
	 * 将给定的日期字符串格式化为日期+时分秒 23:59:59
	 * @author: lihong
	 * @param endDate
	 * @return
	 */
	public static String String2End(String endDate) {
		return endDate + " 23:59:59";
	}
	
	/**
	 * 将给定日期串转化为当天起始时间
	 * @param startDate
	 * @return
	 * @throws ParseException
	 */
	public static Calendar str2Begin(String startDate) throws ParseException{
		startDate += " 00:00:00";
		return string2Calendar(startDate);
	}
	
	/**
	 * 将给定日期串转化为当天结束时间
	 * @param endDate
	 * @return
	 * @throws ParseException
	 */
	public static Calendar str2End(String endDate) throws ParseException{
		endDate += " 23:59:59";
		return string2Calendar(endDate);
	}
	
	/**
	 * 得到一个月的第一日和最后一日
	 * @param monthStr
	 * @return [0] 月的第一天，[1]月的最后一天
	 * @throws ParseException
	 */
	public static Calendar[] getMonthStartAndEnd(String monthStr) throws ParseException {
		Calendar[] mse = new Calendar[2];
		mse[0] = string2Calendar(monthStr, MONTH_FORMAT);
		if (null == mse[0]) {
			mse[0] = Calendar.getInstance();
			mse[0].set(Calendar.DATE, 1);
		}
		mse[1] = (Calendar) mse[0].clone();
		mse[1].set(Calendar.MONTH, mse[1].get(Calendar.MONTH) + 1);
		mse[1].set(Calendar.DATE, mse[1].get(Calendar.DATE) - 1);
		return mse;
	}
	
	/**
	 * 得到一年的第一日和当前选择的月份的最后一日
	 * @param monthStr
	 * @return [0] 年的第一天，[1]当前选择月的最后一天
	 * @throws ParseException
	 */
	public static Calendar[] getYearStartAndEnd(String monthStr) throws ParseException {
//		Calendar[] mse = new Calendar[2];
//		mse[0] = string2Calendar(monthStr, MONTH_FORMAT);
//		if (null == mse[0]) {
//			mse[0] = Calendar.getInstance();
//			mse[0].set(Calendar.DATE, 1);
//		}
//		// 设置为年的第一个月
//		mse[0].set(Calendar.MONTH, 0);
//		mse[1] = (Calendar) mse[0].clone();
//		// 设置为下一年的第一个月的第一天
//		mse[1].set(Calendar.YEAR, mse[1].get(Calendar.YEAR) + 1);
//		// 得到当前年的最后一天
//		mse[1].set(Calendar.DATE, mse[1].get(Calendar.DATE) - 1);
//		return mse;
		Calendar[] mse = getMonthStartAndEnd(monthStr);
		mse[0].set(Calendar.MONTH, 0);
		return mse;
	}
	
	/**
	 * 得到年、季度、月份的季度Index
	 * @param monthStr
	 * @return [0] 年
	 * [1] 季度
	 * [2] 月份在季度的Index
	 * @throws ParseException
	 */
	public static int[] getYearJiduMonthIndex(String monthStr) throws ParseException {
		int[] timeArray = new int[3];
		Calendar calendar = string2Calendar(monthStr, MONTH_FORMAT);
		if (null == calendar) {
			calendar = Calendar.getInstance();
		}
		// 得到年份
		timeArray[0] = calendar.get(Calendar.YEAR);
//		int jiduOfYear = 4;
		// 得到第几个季度
		timeArray[1] = (calendar.get(Calendar.MONTH) / 4) + 1;
		// 得到季度的第几个月
		timeArray[2] = calendar.get(Calendar.MONTH) % 3;
		return timeArray;
	}
	public static String dateToString(Date date, String style){
	 	DateFormat df = new SimpleDateFormat(style); 
        return df.format(date); 
	}
	
	public static Date strToDate(String dateStr,String pattern){
		SimpleDateFormat sdf=new SimpleDateFormat(pattern);
		Date date = null;
		try {
			date = sdf.parse(dateStr);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return date;
	}
    public static void main(String[] args) {
       // System.out.print(String2YearMonth("2012-10-30"));
        System.out.print(calendar2String(Calendar.getInstance(),
				"yyyy-MM-dd"));
    }
}
